home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / source / snip9503 / jmalloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-14  |  21.3 KB  |  651 lines
  1. /*--------------------------------------------------------------*/
  2. /* Debugging extension by Jeff Dunlop                           */
  3. /* Copyright 1992-1993, DB/Soft Publishing Co.                  */
  4. /* License is hereby granted for use of JMalloc as a debugging  */
  5. /* aid in any program.  JMalloc may not be sold or distributed  */
  6. /* as or part of any for-profit debugging program or library    */
  7. /* nor may it be included in any for-profit library that offers */
  8. /* debugging features.  Any redistribution of JMalloc source    */
  9. /* must include this copyright notice.                          */
  10. /*--------------------------------------------------------------*/
  11.  
  12. /*-------------------------[ jmalloc.c ]------------------------*/
  13. /*                 drop-in for malloc with diags                */
  14. /*--------------------------------------------------------------*/
  15.  
  16. /*--------------------------------------------------------------*/
  17. /*---------------------------[ notes ]--------------------------*/
  18. /*--------------------------------------------------------------*/
  19.  
  20. /*
  21.  
  22. The J... macros are intended for use on JMalloc'd memory blocks.  The
  23. A... macros are intended for use on auto array blocks and will only
  24. work if the base of the array is passed.  They will not work if the
  25. address of an array element is passed.  All functions are designed to
  26. be nearly drop-in replacements for standard library functions.  The one
  27. case where debugging libraries traditionally fall short is when a block
  28. operation occurs on an automatic array in a position other than at the
  29. head.  This library could conceivably be extended to include a class of
  30. functions that allow you to pass both a block and an offset into that
  31. block so that the block and its size can be checked.  My style of
  32. programming eschews this practice so I haven't had any motivation to so
  33. extend this library.  Note that such an extension would depart slightly
  34. from the standard syntax of the runtime library because of the
  35. additional passed parameter.
  36.  
  37. JMemcheck(0) may be called at any time for an overwrite check of all
  38. allocated blocks.  JMemcheck(1) additionally checks for orphaned blocks
  39. and should be called just before program shutdown.
  40.  
  41. All functions are designed to log any detectable errors when the errors
  42. occur, and to report either the line number of the overwrite, or the
  43. line number that the block was allocated on, depending on which is more
  44. useful.  Any blocks that are damaged by non-JMalloc functions will not
  45. be noticed until they are JFree'd and will be tougher to debug.
  46. Regardless of the damage that a function call produces, JMalloc never
  47. departs from the runtime library's behavior.  Its job is to report,
  48. nothing more.  All allocated blocks (except for JCalloc calls) are
  49. dirtied and all blocks are dirtied before they are freed.  If you are
  50. referencing freed memory or not initializing a new block, it will be
  51. very obvious.  All blocks have an extra check byte that is checked when
  52. the block is freed or during JMemcheck.  This doesn't catch random
  53. memory writes, but it does catch overruns.
  54.  
  55. */
  56.  
  57. /*--------------------------------------------------------------*/
  58. /*-----------------------[ header files ]-----------------------*/
  59. /*--------------------------------------------------------------*/
  60.  
  61. #define DBUG
  62.  
  63. #if defined __TURBOC__
  64. #include <alloc.h>
  65. #include <mem.h>
  66. #else
  67. #include <malloc.h>
  68. #include <memory.h>
  69. #endif
  70.  
  71. #include <stdarg.h>
  72. #include <stdio.h>
  73. #include <stdlib.h>
  74. #include <string.h>
  75. #include "jmalloc.h"
  76.  
  77. /*--------------------------------------------------------------*/
  78. /*--------------------[ local prototypes ]----------------------*/
  79. /*--------------------------------------------------------------*/
  80.  
  81. static MLINK *JMemOwner(char *Addr);
  82.  
  83. /*--------------------------------------------------------------*/
  84. /*---------------------[ global variables ]---------------------*/
  85. /*--------------------------------------------------------------*/
  86.  
  87. MLINK *MalTop;                        /* top of allocation chain */
  88.  
  89. void db_prn(char *fmt, ...)
  90. {
  91.     va_list p;
  92.  
  93.     va_start(p, fmt);
  94.     vprintf(fmt, p);
  95.     putchar('\n');
  96.     va_end(p);
  97. }
  98.  
  99. void *j_deref(void *a, char *file, int line)
  100. {
  101.     if ( a == NULL )
  102.     {
  103.         DBUG_PRINT("alloc", ("Dereferenced NULL pointer - %s: line %d",
  104.             file, line));
  105.     }
  106.     return a;
  107. }
  108.  
  109. /*-------------------------[ j_malloc ]-------------------------*/
  110. /*            Memory allocator with diagnostics                 */
  111. /*--------------------------------------------------------------*/
  112. /* input:                                                       */
  113. /*      Size = number of bytes to allocate                      */
  114. /* local:                                                       */
  115. /*      CurMal = pointer current mem struct                     */
  116. /*      PrevMal = pointer to previous mem struct                */
  117. /*      AllocAddr = pointer to allocated ram                    */
  118. /* return:                                                      */
  119. /*      address of allocated ram, or NULL on error              */
  120. /* note:                                                        */
  121. /*       use the JMalloc macro                                  */
  122. /*--------------------------------------------------------------*/
  123.  
  124. static int memc;
  125.  
  126. void *j_malloc(unsigned Size, char *file, int line)
  127. {
  128.     /* 1. Allocate the memory */
  129.     /* 2. Add to allocation chain */
  130.     /* 3. Fill with non-null */
  131.  
  132.     MLINK *CurMal = MalTop,
  133.           *PrevMal;
  134.  
  135.     void *AllocAddr;
  136.  
  137.     /* Allocate the memory + 1 (for check byte) */
  138.  
  139.     if ( (AllocAddr = malloc(Size + 1)) == NULL )
  140.     {
  141.         DBUG_PRINT("alloc", ("Allocation failed: %s Line %d", file, line));
  142.         return((void*)0);
  143.     }
  144.  
  145.     /* Add to the allocation chain */
  146.  
  147.     PrevMal = CurMal;
  148.     while ( CurMal != NULL )
  149.     {
  150.         PrevMal = CurMal;
  151.         CurMal = CurMal->NextLink;
  152.     }
  153.     if ( (CurMal = malloc(sizeof *CurMal)) == NULL )
  154.     {
  155.         DBUG_PRINT("alloc", ("Control allocation failed: %s Line %d", file,
  156.             line));
  157.         return(AllocAddr);
  158.     }
  159.  
  160.     /* Deal with bootstrap */
  161.     if ( PrevMal == NULL )
  162.         MalTop = CurMal;
  163.     else
  164.         PrevMal->NextLink = CurMal;
  165.     CurMal->NextLink = NULL;
  166.     CurMal->MAddr = AllocAddr;
  167.     CurMal->MSize = Size;
  168.     CurMal->MLine = line;
  169.     AStrCpy(CurMal->MFile, file);
  170.  
  171.     memset(AllocAddr, CKBYT, Size + 1);
  172.     memc++;
  173.     return(AllocAddr);
  174. }
  175.  
  176. /*-------------------------[ j_calloc ]-------------------------*/
  177. /*            Memory allocator with diagnostics                 */
  178. /*--------------------------------------------------------------*/
  179. /* method:                                                      */
  180. /*      - Allocate the memory via JMalloc                       */
  181. /*      - Fill with null                                        */
  182. /*      - Set check-byte                                        */
  183. /* input:                                                       */
  184. /*      Size = number of bytes to allocate                      */
  185. /* local:                                                       */
  186. /*      CurCal = pointer current mem struct                     */
  187. /*      PrevCal = pointer to previous mem struct                */
  188. /*      AllocAddr = pointer to allocated ram                    */
  189. /* return:                                                      */
  190. /*      address of allocated ram, or NULL on error              */
  191. /*  note:                                                       */
  192. /*      Use the JCalloc macro                                   */
  193. /*--------------------------------------------------------------*/
  194.  
  195. void *j_calloc(unsigned Size, unsigned SizEach, char *file, int line)
  196. {
  197.     char *AllocAddr;
  198.  
  199.     /* Allocate the memory + 1 (for check byte) */
  200.  
  201.     /* Do not piss over NULL return - JMalloc handled that */
  202.     if ( (AllocAddr = j_malloc(Size * SizEach, file, line)) != NULL )
  203.     {
  204.         /* Prep allocated ram */
  205.         memset(AllocAddr, 0, Size * SizEach);
  206.         AllocAddr[Size * SizEach] = CKBYT;
  207.     }
  208.  
  209.     return(AllocAddr);
  210. }
  211.  
  212. /*-------------------------[ j_realloc ]------------------------*/
  213. /*                     Reallocate memory                        */
  214. /*--------------------------------------------------------------*/
  215. /* input:                                                       */
  216. /*  Addr = block's current address                              */
  217. /*  Size = block's new size                                     */
  218. /* return:                                                      */
  219. /*  Block's new address, or NULL if memory not available.       */
  220. /* note:                                                        */
  221. /*  Use the JRealloc macro.                                     */
  222. /*  If NULL is returned, Addr was also freed                    */
  223. /*--------------------------------------------------------------*/
  224.  
  225. void *j_realloc(void *Addr, unsigned Size, char *file, int line)
  226. {
  227.     MLINK *CurMal = MalTop;
  228.  
  229.     void *tmp;
  230.  
  231.     if ( Addr == NULL )
  232.         return(j_malloc(Size, file, line));
  233.     /* Find the old block in the alloc list */
  234.     while ( CurMal->MAddr != Addr && CurMal != NULL )
  235.         CurMal = CurMal->NextLink;
  236.     if ( CurMal == NULL )
  237.     {
  238.         /* Just call the standard realloc since we don't know anything
  239.          * about this block
  240.          */
  241.         DBUG_PRINT("alloc", ("Realloc attempted on unrecorded block: %s "
  242.             "Line %d", file, line));
  243.         return(realloc(Addr, Size));
  244.     }
  245.     else
  246.     {
  247.         tmp = j_malloc(Size, file, line);
  248.         if ( tmp != NULL )
  249.         {
  250.             memcpy(tmp, Addr, min(CurMal->MSize, Size));
  251.             j_free(Addr, file, line);
  252.         }
  253.         else
  254.         {
  255.             j_free(Addr, file, line);
  256.             return NULL;
  257.         }
  258.     }
  259.     return(tmp);
  260. }
  261.  
  262. /*-------------------------[ j_free ]---------------------------*/
  263. /*           Memory deallocator with diagnostics                */
  264. /*--------------------------------------------------------------*/
  265. /* input:                                                       */
  266. /*      AllocAddr = pointer to ram to deallocate                */
  267. /* local:                                                       */
  268. /*      CurMal = pointer to current mem struct                  */
  269. /*      PrevMal = pointer to prev mem struct                    */
  270. /* note:                                                        */
  271. /*      This function is designed to be implemented with the    */
  272. /*      macro JFree                                             */
  273. /*--------------------------------------------------------------*/
  274.  
  275. void j_free(void *AllocAddr, char *file, int line)
  276. {
  277.     /* 1. Find the block in the alloc list */
  278.     /* 2. Check for check-byte overwrite   */
  279.     /* 3. Remove allocation record         */
  280.     /* 3. Free the ram                     */
  281.  
  282.     MLINK *CurMal = MalTop,
  283.           *PrevMal = MalTop;
  284.  
  285.     /* Find the block in the alloc list */
  286.     while ( CurMal != NULL && CurMal->MAddr != AllocAddr )
  287.     {
  288.         PrevMal = CurMal;
  289.         CurMal = CurMal->NextLink;
  290.     }
  291.     if ( CurMal == NULL )
  292.     {
  293.         DBUG_PRINT("alloc", ("Freeing an unrecorded block: %s %d", file,
  294.             line));
  295.     }
  296.     else
  297.     {
  298.         /* Check for check-byte overwrite */
  299.         if ( CurMal->MAddr[CurMal->MSize] != CKBYT )
  300.             DBUG_PRINT("alloc", ("Memory overrun detected on block allocated"
  301.             " at %s Line %d", CurMal->MFile, CurMal->MLine));
  302.         memset(AllocAddr, DIRTY, CurMal->MSize + 1);
  303.  
  304.         if ( CurMal == MalTop )
  305.             MalTop = CurMal->NextLink;
  306.         else
  307.             PrevMal->NextLink = CurMal->NextLink;
  308.         free(CurMal);
  309.     }
  310.  
  311.     /* Free the ram regardless of validity */
  312.     free(AllocAddr);
  313.     memc--;
  314.     return;
  315. }
  316.  
  317. /*-------------------------[ JMemcheck ]------------------------*/
  318. /*                Verify memory chain integrity                 */
  319. /*--------------------------------------------------------------*/
  320. /* input:                                                       */
  321. /*  CheckFree != if currently allocated blocks are to be        */
  322. /*  reported                                                    */
  323. /* local:                                                       */
  324. /*      i = link number                                         */
  325. /*      CurMal = link pointer                                   */
  326. /*      status = current error condition                        */
  327. /* return:                                                      */
  328. /*      -1 = error,                                             */
  329. /*      0 = no error detected                                   */
  330. /*--------------------------------------------------------------*/
  331.  
  332. int j_memcheck(int CheckFree)
  333. {
  334.     int status = 0;
  335.  
  336.     MLINK *CurMal = MalTop;
  337.  
  338.     /* Walk the alloc list */
  339.     if ( CheckFree >= 2 )
  340.     {
  341.         DBUG_PRINT("alloc", ("There should be %d unfreed blocks", memc));
  342.     }
  343.  
  344.     while ( CurMal != NULL )
  345.     {
  346.         if ( CurMal->MAddr[CurMal->MSize] != CKBYT )
  347.         {
  348.             DBUG_PRINT("alloc", ("Memory overrun detected in link "
  349.             "allocated at %s Line %d", CurMal->MFile, CurMal->MLine));
  350.             status = -1;
  351.         }
  352.         if ( CheckFree >= 1 )
  353.         {
  354.             DBUG_PRINT("alloc", ("Unfreed block of size %d allocated at "
  355.             "%s Line %d", CurMal->MSize, CurMal->MFile, CurMal->MLine));
  356.             status = -1;
  357.         }
  358.         CurMal = CurMal->NextLink;
  359.     }
  360.     return(status);
  361. }
  362.  
  363. /*-------------------------[ JMemValid ]------------------------*/
  364. /*          Verify an address is in a JMalloc space             */
  365. /*--------------------------------------------------------------*/
  366.  
  367. int JMemValid(char *Addr)
  368. {
  369.     MLINK *CurMal = MalTop;
  370.  
  371.     while ( CurMal != NULL )
  372.     {
  373.         if ( Addr >= CurMal->MAddr && Addr <= CurMal->MAddr + CurMal->MSize )
  374.             return(TRUE);
  375.         CurMal = CurMal->NextLink;
  376.     }
  377.  
  378.     return(FALSE);
  379. }
  380.  
  381. /*-------------------------[ JMemOwner ]------------------------*/
  382. /*            Return the owner of a block of ram                */
  383. /*--------------------------------------------------------------*/
  384.  
  385. static MLINK *JMemOwner(char *Addr)
  386. {
  387.     MLINK *CurMal = MalTop;
  388.  
  389.     while ( CurMal != NULL )
  390.     {
  391.         unsigned long Cur = (unsigned long)CurMal->MAddr,
  392.                       Adr = (unsigned long)Addr;
  393.         if ( Adr >= Cur && Adr <= Cur + CurMal->MSize )
  394.             return(CurMal);
  395.         CurMal = CurMal->NextLink;
  396.     }
  397.  
  398.     return((void*)NULL);
  399. }
  400.  
  401. /*-------------------------[ j_strcpy ]-------------------------*/
  402. /*          String copy with checks and protections             */
  403. /*--------------------------------------------------------------*/
  404.  
  405. char *j_strcpy(char *__dest, const char *__src, char *file, int line)
  406. {
  407.     MLINK *MemOwner = JMemOwner(__dest);
  408.  
  409.     if ( MemOwner == NULL )
  410.     {
  411.         DBUG_PRINT("alloc", ("Strcpy destination invalid - %s: line %d",
  412.             file, line));
  413.     }
  414.     else if ( strlen(__src) > MemOwner->MAddr + MemOwner->MSize - __dest )
  415.     {
  416.         DBUG_PRINT("alloc", ("Strcpy destination overrun - %s: line %d",
  417.             file, line));
  418.     }
  419.     return(strcpy(__dest, __src));
  420. }
  421.  
  422. /*-------------------------[ j_strncpy ]------------------------*/
  423. /*                 String n copy with checks                    */
  424. /*--------------------------------------------------------------*/
  425.  
  426. char *j_strncpy(char *__dest, const char *__src, size_t maxlen, char *file,
  427.                 int line)
  428. {
  429.     MLINK *MemOwner = JMemOwner(__dest);
  430.  
  431.     if ( MemOwner == NULL )
  432.     {
  433.         DBUG_PRINT("alloc", ("strncpy destination invalid - %s: line %d",
  434.             file, line));
  435.     }
  436.     else if ( maxlen > MemOwner->MAddr + MemOwner->MSize - __dest )
  437.     {
  438.         DBUG_PRINT("alloc", ("strncpy destination overrun - %s: line %d",
  439.             file, line));
  440.     }
  441.  
  442.     return(strncpy(__dest, __src, maxlen));
  443. }
  444.  
  445. char *j_strcat(char *__dest, char *__src, char *file, int line)
  446. {
  447.     MLINK *MemOwner = JMemOwner(__dest);
  448.  
  449.     if ( MemOwner == NULL )
  450.     {
  451.         DBUG_PRINT("alloc", ("strcat destination invalid - %s: line %d",
  452.             file, line));
  453.     }
  454.     else if ( strlen(MemOwner->MAddr) + strlen(__src) + 1 > MemOwner->MSize )
  455.     {
  456.         DBUG_PRINT("alloc", ("strcat destination overrun - %s: line %d",
  457.             file, line));
  458.     }
  459.  
  460.     return(strcat(__dest, __src));
  461. }
  462.  
  463. char *j_strdup(char *__str, char *file, int line)
  464. {
  465.     char *p = j_malloc(strlen(__str) + 1, file, line);
  466.  
  467.     if ( p != NULL )
  468.     {
  469.         j_strcpy(p, __str, file, line);
  470.     }
  471.     return(p);
  472. }
  473.  
  474. char *j_strnset(char *str, int ch, size_t n, char *file, int line)
  475. {
  476.     MLINK *MemOwner = JMemOwner(str);
  477.  
  478.     if ( MemOwner == NULL )
  479.     {
  480.         DBUG_PRINT("alloc", ("strnset destination invalid - %s: line %d",
  481.             file, line));
  482.     }
  483.     return(strnset(str, ch, n));
  484. }
  485.  
  486. char *j_strset(char *str, int ch, char *file, int line)
  487. {
  488.     MLINK *MemOwner = JMemOwner(str);
  489.  
  490.     if ( MemOwner == NULL )
  491.     {
  492.         DBUG_PRINT("alloc", ("strset destination invalid - %s: line %d",
  493.             file, line));
  494.     }
  495.     return(strset(str, ch));
  496. }
  497.  
  498. /*------------------------[ j_checkstr ]------------------------*/
  499. /*             Check a MLINK string for problems                */
  500. /* j_sprintf      sprintf replacement                           */
  501. /*--------------------------------------------------------------*/
  502.  
  503. int j_checkstr(MLINK *str)
  504. {
  505.     if ( str->MAddr[str->MSize] != CKBYT || strlen(str->MAddr) > str->MSize - 1 )
  506.     {
  507.         DBUG_PRINT("alloc",
  508.             ("Bad string, allocated at %s Line %d", str->MFile, str->MLine));
  509.         return 1;
  510.     }
  511.     return 0;
  512. }
  513.  
  514. void *j_memcpy(void *dest, const void *src, size_t n, char *file, int line)
  515. {
  516.     MLINK *MemOwner = JMemOwner(dest);
  517.  
  518.     if ( MemOwner == NULL )
  519.     {
  520.         DBUG_PRINT("alloc", ("memcpy destination invalid - %s: line %d",
  521.             file, line));
  522.     }
  523.     else if ( n > MemOwner->MAddr + MemOwner->MSize - dest )
  524.     {
  525.         DBUG_PRINT("alloc", ("memcpy destination overrun - %s: line %d",
  526.             file, line));
  527.     }
  528.  
  529.     return(memcpy(dest, src, n));
  530. }
  531.  
  532. void *j_memset(void *dest, int ch, size_t n, char *file, int line)
  533. {
  534.     MLINK *MemOwner = JMemOwner(dest);
  535.  
  536.     if ( MemOwner == NULL )
  537.     {
  538.         DBUG_PRINT("alloc", ("memset destination invalid - %s: line %d",
  539.             file, line));
  540.     }
  541.     else if ( n > MemOwner->MAddr + MemOwner->MSize - dest )
  542.     {
  543.         DBUG_PRINT("alloc", ("memset destination overrun - %s: line %d",
  544.             file, line));
  545.     }
  546.  
  547.     return(memset(dest, ch, n));
  548. }
  549.  
  550. char *a_strcpy(char *__dest, const char *__src, int size, char *file,
  551.     int line)
  552. {
  553.     if ( strlen(__src) >= size)
  554.         DBUG_PRINT("alloc", ("strcpy destination overrun - %s: line %d",
  555.             file, line));
  556.     return(strcpy(__dest, __src));
  557. }
  558.  
  559. char *a_strncpy(char *dest, const char *src, size_t n, int size, char *file,
  560.     int line)
  561. {
  562.     if ( n >= size )
  563.         DBUG_PRINT("alloc", ("strncpy destination overrun - %s: line %d",
  564.             file, line));
  565.     return(strncpy(dest, src, n));
  566. }
  567.  
  568. char *a_strcat(char *dest, const char *src, int size, char *file, int line)
  569. {
  570.     if ( strlen(dest) + strlen(src) + 1 > size )
  571.         DBUG_PRINT("alloc", ("strcat destination overrun = %s: line %d",
  572.             file, line));
  573.     return(strcat(dest, src));
  574. }
  575.  
  576. char *a_strnset(char *str, int ch, size_t n, int size, char *file, int line)
  577. {
  578.     if ( n + 1 > size )
  579.         DBUG_PRINT("alloc", ("strnset destination overrun - %s: line %d",
  580.             file, line));
  581.     return(strnset(str, ch, n));
  582. }
  583.  
  584. void *a_memcpy(void *dest, const void *src, size_t n, int size, char *file,
  585.              int line)
  586. {
  587.     if ( n > size )
  588.         DBUG_PRINT("alloc", ("memcpy destination overrun - %s: line %d",
  589.             file, line));
  590.     return(memcpy(dest, src, n));
  591. }
  592.  
  593. void *a_memset(void *dest, int ch, size_t n, int size, char *file, int line)
  594. {
  595.     if ( n > size )
  596.         DBUG_PRINT("alloc", ("memset destination overrun - %s: line %d",
  597.             file, line));
  598.     return memset(dest, ch, n);
  599. }
  600.  
  601. #ifdef TEST
  602. int main(int argc, char *argv[])
  603. {
  604.     char *new,
  605.          *p,
  606.          *q,
  607.          r[30],
  608.          *s[256] = {NULL};
  609.     int i = 1;
  610.  
  611.     while ( (p = argv[i++]) != NULL )
  612.     {
  613.         switch ( *p++ )
  614.             case '-':
  615.                 switch ( *p++ )
  616.                     case '#':
  617.                         DBUG_PUSH(argv[i - 1]);
  618.     }
  619.     new = JCalloc(64, 56);
  620.     new = JRealloc(new, 64);
  621.     JStrCpy(new + 10, "Test string");
  622.     DBUG_PRINT("alloc", ("r is invalid"));
  623.     JStrCpy(r, "Test");
  624.     q = JCalloc(4, 4);
  625.     q[4 * 4] = 3;
  626.  
  627.     DBUG_PRINT("alloc", ("p was never allocated"));
  628.     JFree(p);
  629.  
  630.     i = 0;
  631.  
  632.     DBUG_PRINT("alloc", ("Deplete memory"));
  633.     do
  634.     {
  635.         s[i] = JMalloc(32000);
  636.         i++;
  637.     } while ( s[i - 1] != NULL );
  638.  
  639.     i = 0;
  640.     while ( s[i] != NULL )
  641.     {
  642.         JFree(s[i++]);
  643.     }
  644.  
  645.     DBUG_PRINT("alloc", ("New and q are orphaned blocks"));
  646.     DBUG_PRINT("alloc", ("q has an overrun"));
  647.     JMemcheck(1);
  648.     return(0);
  649. }
  650. #endif
  651.